home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / reiserfs_fs_sb.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  22.0 KB  |  533 lines
  1. /* Copyright 1996-2000 Hans Reiser, see reiserfs/README for licensing
  2.  * and copyright details */
  3.  
  4. #ifndef _LINUX_REISER_FS_SB
  5. #define _LINUX_REISER_FS_SB
  6.  
  7. #ifdef __KERNEL__
  8. #include <linux/workqueue.h>
  9. #include <linux/rwsem.h>
  10. #endif
  11.  
  12. typedef enum {
  13.     reiserfs_attrs_cleared = 0x00000001,
  14. } reiserfs_super_block_flags;
  15.  
  16. /* struct reiserfs_super_block accessors/mutators
  17.  * since this is a disk structure, it will always be in 
  18.  * little endian format. */
  19. #define sb_block_count(sbp)         (le32_to_cpu((sbp)->s_v1.s_block_count))
  20. #define set_sb_block_count(sbp,v)   ((sbp)->s_v1.s_block_count = cpu_to_le32(v))
  21. #define sb_free_blocks(sbp)         (le32_to_cpu((sbp)->s_v1.s_free_blocks))
  22. #define set_sb_free_blocks(sbp,v)   ((sbp)->s_v1.s_free_blocks = cpu_to_le32(v))
  23. #define sb_root_block(sbp)          (le32_to_cpu((sbp)->s_v1.s_root_block))
  24. #define set_sb_root_block(sbp,v)    ((sbp)->s_v1.s_root_block = cpu_to_le32(v))
  25.  
  26. #define sb_jp_journal_1st_block(sbp)  \
  27.               (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_1st_block))
  28. #define set_sb_jp_journal_1st_block(sbp,v) \
  29.               ((sbp)->s_v1.s_journal.jp_journal_1st_block = cpu_to_le32(v))
  30. #define sb_jp_journal_dev(sbp) \
  31.               (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_dev))
  32. #define set_sb_jp_journal_dev(sbp,v) \
  33.               ((sbp)->s_v1.s_journal.jp_journal_dev = cpu_to_le32(v))
  34. #define sb_jp_journal_size(sbp) \
  35.               (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_size))
  36. #define set_sb_jp_journal_size(sbp,v) \
  37.               ((sbp)->s_v1.s_journal.jp_journal_size = cpu_to_le32(v))
  38. #define sb_jp_journal_trans_max(sbp) \
  39.               (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_trans_max))
  40. #define set_sb_jp_journal_trans_max(sbp,v) \
  41.               ((sbp)->s_v1.s_journal.jp_journal_trans_max = cpu_to_le32(v))
  42. #define sb_jp_journal_magic(sbp) \
  43.               (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_magic))
  44. #define set_sb_jp_journal_magic(sbp,v) \
  45.               ((sbp)->s_v1.s_journal.jp_journal_magic = cpu_to_le32(v))
  46. #define sb_jp_journal_max_batch(sbp) \
  47.               (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_max_batch))
  48. #define set_sb_jp_journal_max_batch(sbp,v) \
  49.               ((sbp)->s_v1.s_journal.jp_journal_max_batch = cpu_to_le32(v))
  50. #define sb_jp_jourmal_max_commit_age(sbp) \
  51.               (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_max_commit_age))
  52. #define set_sb_jp_journal_max_commit_age(sbp,v) \
  53.               ((sbp)->s_v1.s_journal.jp_journal_max_commit_age = cpu_to_le32(v))
  54.  
  55. #define sb_blocksize(sbp)          (le16_to_cpu((sbp)->s_v1.s_blocksize))
  56. #define set_sb_blocksize(sbp,v)    ((sbp)->s_v1.s_blocksize = cpu_to_le16(v))
  57. #define sb_oid_maxsize(sbp)        (le16_to_cpu((sbp)->s_v1.s_oid_maxsize))
  58. #define set_sb_oid_maxsize(sbp,v)  ((sbp)->s_v1.s_oid_maxsize = cpu_to_le16(v))
  59. #define sb_oid_cursize(sbp)        (le16_to_cpu((sbp)->s_v1.s_oid_cursize))
  60. #define set_sb_oid_cursize(sbp,v)  ((sbp)->s_v1.s_oid_cursize = cpu_to_le16(v))
  61. #define sb_umount_state(sbp)       (le16_to_cpu((sbp)->s_v1.s_umount_state))
  62. #define set_sb_umount_state(sbp,v) ((sbp)->s_v1.s_umount_state = cpu_to_le16(v))
  63. #define sb_fs_state(sbp)           (le16_to_cpu((sbp)->s_v1.s_fs_state))
  64. #define set_sb_fs_state(sbp,v)     ((sbp)->s_v1.s_fs_state = cpu_to_le16(v))
  65. #define sb_hash_function_code(sbp) \
  66.               (le32_to_cpu((sbp)->s_v1.s_hash_function_code))
  67. #define set_sb_hash_function_code(sbp,v) \
  68.               ((sbp)->s_v1.s_hash_function_code = cpu_to_le32(v))
  69. #define sb_tree_height(sbp)        (le16_to_cpu((sbp)->s_v1.s_tree_height))
  70. #define set_sb_tree_height(sbp,v)  ((sbp)->s_v1.s_tree_height = cpu_to_le16(v))
  71. #define sb_bmap_nr(sbp)            (le16_to_cpu((sbp)->s_v1.s_bmap_nr))
  72. #define set_sb_bmap_nr(sbp,v)      ((sbp)->s_v1.s_bmap_nr = cpu_to_le16(v))
  73. #define sb_version(sbp)            (le16_to_cpu((sbp)->s_v1.s_version))
  74. #define set_sb_version(sbp,v)      ((sbp)->s_v1.s_version = cpu_to_le16(v))
  75.  
  76. #define sb_reserved_for_journal(sbp) \
  77.               (le16_to_cpu((sbp)->s_v1.s_reserved_for_journal))
  78. #define set_sb_reserved_for_journal(sbp,v) \
  79.               ((sbp)->s_v1.s_reserved_for_journal = cpu_to_le16(v))
  80.  
  81. /* LOGGING -- */
  82.  
  83. /* These all interelate for performance.  
  84. **
  85. ** If the journal block count is smaller than n transactions, you lose speed. 
  86. ** I don't know what n is yet, I'm guessing 8-16.
  87. **
  88. ** typical transaction size depends on the application, how often fsync is
  89. ** called, and how many metadata blocks you dirty in a 30 second period.  
  90. ** The more small files (<16k) you use, the larger your transactions will
  91. ** be.
  92. ** 
  93. ** If your journal fills faster than dirty buffers get flushed to disk, it must flush them before allowing the journal
  94. ** to wrap, which slows things down.  If you need high speed meta data updates, the journal should be big enough
  95. ** to prevent wrapping before dirty meta blocks get to disk.
  96. **
  97. ** If the batch max is smaller than the transaction max, you'll waste space at the end of the journal
  98. ** because journal_end sets the next transaction to start at 0 if the next transaction has any chance of wrapping.
  99. **
  100. ** The large the batch max age, the better the speed, and the more meta data changes you'll lose after a crash.
  101. **
  102. */
  103.  
  104. /* don't mess with these for a while */
  105.                 /* we have a node size define somewhere in reiserfs_fs.h. -Hans */
  106. #define JOURNAL_BLOCK_SIZE  4096    /* BUG gotta get rid of this */
  107. #define JOURNAL_MAX_CNODE   1500    /* max cnodes to allocate. */
  108. #define JOURNAL_HASH_SIZE 8192
  109. #define JOURNAL_NUM_BITMAPS 5    /* number of copies of the bitmaps to have floating.  Must be >= 2 */
  110.  
  111. /* One of these for every block in every transaction
  112. ** Each one is in two hash tables.  First, a hash of the current transaction, and after journal_end, a
  113. ** hash of all the in memory transactions.
  114. ** next and prev are used by the current transaction (journal_hash).
  115. ** hnext and hprev are used by journal_list_hash.  If a block is in more than one transaction, the journal_list_hash
  116. ** links it in multiple times.  This allows flush_journal_list to remove just the cnode belonging
  117. ** to a given transaction.
  118. */
  119. struct reiserfs_journal_cnode {
  120.     struct buffer_head *bh;    /* real buffer head */
  121.     struct super_block *sb;    /* dev of real buffer head */
  122.     __u32 blocknr;        /* block number of real buffer head, == 0 when buffer on disk */
  123.     unsigned long state;
  124.     struct reiserfs_journal_list *jlist;    /* journal list this cnode lives in */
  125.     struct reiserfs_journal_cnode *next;    /* next in transaction list */
  126.     struct reiserfs_journal_cnode *prev;    /* prev in transaction list */
  127.     struct reiserfs_journal_cnode *hprev;    /* prev in hash list */
  128.     struct reiserfs_journal_cnode *hnext;    /* next in hash list */
  129. };
  130.  
  131. struct reiserfs_bitmap_node {
  132.     int id;
  133.     char *data;
  134.     struct list_head list;
  135. };
  136.  
  137. struct reiserfs_list_bitmap {
  138.     struct reiserfs_journal_list *journal_list;
  139.     struct reiserfs_bitmap_node **bitmaps;
  140. };
  141.  
  142. /*
  143. ** one of these for each transaction.  The most important part here is the j_realblock.
  144. ** this list of cnodes is used to hash all the blocks in all the commits, to mark all the
  145. ** real buffer heads dirty once all the commits hit the disk,
  146. ** and to make sure every real block in a transaction is on disk before allowing the log area
  147. ** to be overwritten */
  148. struct reiserfs_journal_list {
  149.     unsigned long j_start;
  150.     unsigned long j_state;
  151.     unsigned long j_len;
  152.     atomic_t j_nonzerolen;
  153.     atomic_t j_commit_left;
  154.     atomic_t j_older_commits_done;    /* all commits older than this on disk */
  155.     struct mutex j_commit_mutex;
  156.     unsigned long j_trans_id;
  157.     time_t j_timestamp;
  158.     struct reiserfs_list_bitmap *j_list_bitmap;
  159.     struct buffer_head *j_commit_bh;    /* commit buffer head */
  160.     struct reiserfs_journal_cnode *j_realblock;
  161.     struct reiserfs_journal_cnode *j_freedlist;    /* list of buffers that were freed during this trans.  free each of these on flush */
  162.     /* time ordered list of all active transactions */
  163.     struct list_head j_list;
  164.  
  165.     /* time ordered list of all transactions we haven't tried to flush yet */
  166.     struct list_head j_working_list;
  167.  
  168.     /* list of tail conversion targets in need of flush before commit */
  169.     struct list_head j_tail_bh_list;
  170.     /* list of data=ordered buffers in need of flush before commit */
  171.     struct list_head j_bh_list;
  172.     int j_refcount;
  173. };
  174.  
  175. struct reiserfs_journal {
  176.     struct buffer_head **j_ap_blocks;    /* journal blocks on disk */
  177.     struct reiserfs_journal_cnode *j_last;    /* newest journal block */
  178.     struct reiserfs_journal_cnode *j_first;    /*  oldest journal block.  start here for traverse */
  179.  
  180.     struct block_device *j_dev_bd;
  181.     fmode_t j_dev_mode;
  182.     int j_1st_reserved_block;    /* first block on s_dev of reserved area journal */
  183.  
  184.     unsigned long j_state;
  185.     unsigned long j_trans_id;
  186.     unsigned long j_mount_id;
  187.     unsigned long j_start;    /* start of current waiting commit (index into j_ap_blocks) */
  188.     unsigned long j_len;    /* length of current waiting commit */
  189.     unsigned long j_len_alloc;    /* number of buffers requested by journal_begin() */
  190.     atomic_t j_wcount;    /* count of writers for current commit */
  191.     unsigned long j_bcount;    /* batch count. allows turning X transactions into 1 */
  192.     unsigned long j_first_unflushed_offset;    /* first unflushed transactions offset */
  193.     unsigned long j_last_flush_trans_id;    /* last fully flushed journal timestamp */
  194.     struct buffer_head *j_header_bh;
  195.  
  196.     time_t j_trans_start_time;    /* time this transaction started */
  197.     struct mutex j_mutex;
  198.     struct mutex j_flush_mutex;
  199.     wait_queue_head_t j_join_wait;    /* wait for current transaction to finish before starting new one */
  200.     atomic_t j_jlock;    /* lock for j_join_wait */
  201.     int j_list_bitmap_index;    /* number of next list bitmap to use */
  202.     int j_must_wait;    /* no more journal begins allowed. MUST sleep on j_join_wait */
  203.     int j_next_full_flush;    /* next journal_end will flush all journal list */
  204.     int j_next_async_flush;    /* next journal_end will flush all async commits */
  205.  
  206.     int j_cnode_used;    /* number of cnodes on the used list */
  207.     int j_cnode_free;    /* number of cnodes on the free list */
  208.  
  209.     unsigned int j_trans_max;    /* max number of blocks in a transaction.  */
  210.     unsigned int j_max_batch;    /* max number of blocks to batch into a trans */
  211.     unsigned int j_max_commit_age;    /* in seconds, how old can an async commit be */
  212.     unsigned int j_max_trans_age;    /* in seconds, how old can a transaction be */
  213.     unsigned int j_default_max_commit_age;    /* the default for the max commit age */
  214.  
  215.     struct reiserfs_journal_cnode *j_cnode_free_list;
  216.     struct reiserfs_journal_cnode *j_cnode_free_orig;    /* orig pointer returned from vmalloc */
  217.  
  218.     struct reiserfs_journal_list *j_current_jl;
  219.     int j_free_bitmap_nodes;
  220.     int j_used_bitmap_nodes;
  221.  
  222.     int j_num_lists;    /* total number of active transactions */
  223.     int j_num_work_lists;    /* number that need attention from kreiserfsd */
  224.  
  225.     /* debugging to make sure things are flushed in order */
  226.     int j_last_flush_id;
  227.  
  228.     /* debugging to make sure things are committed in order */
  229.     int j_last_commit_id;
  230.  
  231.     struct list_head j_bitmap_nodes;
  232.     struct list_head j_dirty_buffers;
  233.     spinlock_t j_dirty_buffers_lock;    /* protects j_dirty_buffers */
  234.  
  235.     /* list of all active transactions */
  236.     struct list_head j_journal_list;
  237.     /* lists that haven't been touched by writeback attempts */
  238.     struct list_head j_working_list;
  239.  
  240.     struct reiserfs_list_bitmap j_list_bitmap[JOURNAL_NUM_BITMAPS];    /* array of bitmaps to record the deleted blocks */
  241.     struct reiserfs_journal_cnode *j_hash_table[JOURNAL_HASH_SIZE];    /* hash table for real buffer heads in current trans */
  242.     struct reiserfs_journal_cnode *j_list_hash_table[JOURNAL_HASH_SIZE];    /* hash table for all the real buffer heads in all 
  243.                                            the transactions */
  244.     struct list_head j_prealloc_list;    /* list of inodes which have preallocated blocks */
  245.     int j_persistent_trans;
  246.     unsigned long j_max_trans_size;
  247.     unsigned long j_max_batch_size;
  248.  
  249.     int j_errno;
  250.  
  251.     /* when flushing ordered buffers, throttle new ordered writers */
  252.     struct delayed_work j_work;
  253.     struct super_block *j_work_sb;
  254.     atomic_t j_async_throttle;
  255. };
  256.  
  257. enum journal_state_bits {
  258.     J_WRITERS_BLOCKED = 1,    /* set when new writers not allowed */
  259.     J_WRITERS_QUEUED,    /* set when log is full due to too many writers */
  260.     J_ABORTED,        /* set when log is aborted */
  261. };
  262.  
  263. #define JOURNAL_DESC_MAGIC "ReIsErLB"    /* ick.  magic string to find desc blocks in the journal */
  264.  
  265. typedef __u32(*hashf_t) (const signed char *, int);
  266.  
  267. struct reiserfs_bitmap_info {
  268.     __u32 free_count;
  269. };
  270.  
  271. struct proc_dir_entry;
  272.  
  273. #if defined( CONFIG_PROC_FS ) && defined( CONFIG_REISERFS_PROC_INFO )
  274. typedef unsigned long int stat_cnt_t;
  275. typedef struct reiserfs_proc_info_data {
  276.     spinlock_t lock;
  277.     int exiting;
  278.     int max_hash_collisions;
  279.  
  280.     stat_cnt_t breads;
  281.     stat_cnt_t bread_miss;
  282.     stat_cnt_t search_by_key;
  283.     stat_cnt_t search_by_key_fs_changed;
  284.     stat_cnt_t search_by_key_restarted;
  285.  
  286.     stat_cnt_t insert_item_restarted;
  287.     stat_cnt_t paste_into_item_restarted;
  288.     stat_cnt_t cut_from_item_restarted;
  289.     stat_cnt_t delete_solid_item_restarted;
  290.     stat_cnt_t delete_item_restarted;
  291.  
  292.     stat_cnt_t leaked_oid;
  293.     stat_cnt_t leaves_removable;
  294.  
  295.     /* balances per level. Use explicit 5 as MAX_HEIGHT is not visible yet. */
  296.     stat_cnt_t balance_at[5];    /* XXX */
  297.     /* sbk == search_by_key */
  298.     stat_cnt_t sbk_read_at[5];    /* XXX */
  299.     stat_cnt_t sbk_fs_changed[5];
  300.     stat_cnt_t sbk_restarted[5];
  301.     stat_cnt_t items_at[5];    /* XXX */
  302.     stat_cnt_t free_at[5];    /* XXX */
  303.     stat_cnt_t can_node_be_removed[5];    /* XXX */
  304.     long int lnum[5];    /* XXX */
  305.     long int rnum[5];    /* XXX */
  306.     long int lbytes[5];    /* XXX */
  307.     long int rbytes[5];    /* XXX */
  308.     stat_cnt_t get_neighbors[5];
  309.     stat_cnt_t get_neighbors_restart[5];
  310.     stat_cnt_t need_l_neighbor[5];
  311.     stat_cnt_t need_r_neighbor[5];
  312.  
  313.     stat_cnt_t free_block;
  314.     struct __scan_bitmap_stats {
  315.         stat_cnt_t call;
  316.         stat_cnt_t wait;
  317.         stat_cnt_t bmap;
  318.         stat_cnt_t retry;
  319.         stat_cnt_t in_journal_hint;
  320.         stat_cnt_t in_journal_nohint;
  321.         stat_cnt_t stolen;
  322.     } scan_bitmap;
  323.     struct __journal_stats {
  324.         stat_cnt_t in_journal;
  325.         stat_cnt_t in_journal_bitmap;
  326.         stat_cnt_t in_journal_reusable;
  327.         stat_cnt_t lock_journal;
  328.         stat_cnt_t lock_journal_wait;
  329.         stat_cnt_t journal_being;
  330.         stat_cnt_t journal_relock_writers;
  331.         stat_cnt_t journal_relock_wcount;
  332.         stat_cnt_t mark_dirty;
  333.         stat_cnt_t mark_dirty_already;
  334.         stat_cnt_t mark_dirty_notjournal;
  335.         stat_cnt_t restore_prepared;
  336.         stat_cnt_t prepare;
  337.         stat_cnt_t prepare_retry;
  338.     } journal;
  339. } reiserfs_proc_info_data_t;
  340. #else
  341. typedef struct reiserfs_proc_info_data {
  342. } reiserfs_proc_info_data_t;
  343. #endif
  344.  
  345. /* reiserfs union of in-core super block data */
  346. struct reiserfs_sb_info {
  347.     struct buffer_head *s_sbh;    /* Buffer containing the super block */
  348.     /* both the comment and the choice of
  349.        name are unclear for s_rs -Hans */
  350.     struct reiserfs_super_block *s_rs;    /* Pointer to the super block in the buffer */
  351.     struct reiserfs_bitmap_info *s_ap_bitmap;
  352.     struct reiserfs_journal *s_journal;    /* pointer to journal information */
  353.     unsigned short s_mount_state;    /* reiserfs state (valid, invalid) */
  354.  
  355.     /* Comment? -Hans */
  356.     void (*end_io_handler) (struct buffer_head *, int);
  357.     hashf_t s_hash_function;    /* pointer to function which is used
  358.                        to sort names in directory. Set on
  359.                        mount */
  360.     unsigned long s_mount_opt;    /* reiserfs's mount options are set
  361.                        here (currently - NOTAIL, NOLOG,
  362.                        REPLAYONLY) */
  363.  
  364.     struct {        /* This is a structure that describes block allocator options */
  365.         unsigned long bits;    /* Bitfield for enable/disable kind of options */
  366.         unsigned long large_file_size;    /* size started from which we consider file to be a large one(in blocks) */
  367.         int border;    /* percentage of disk, border takes */
  368.         int preallocmin;    /* Minimal file size (in blocks) starting from which we do preallocations */
  369.         int preallocsize;    /* Number of blocks we try to prealloc when file
  370.                        reaches preallocmin size (in blocks) or
  371.                        prealloc_list is empty. */
  372.     } s_alloc_options;
  373.  
  374.     /* Comment? -Hans */
  375.     wait_queue_head_t s_wait;
  376.     /* To be obsoleted soon by per buffer seals.. -Hans */
  377.     atomic_t s_generation_counter;    // increased by one every time the
  378.     // tree gets re-balanced
  379.     unsigned long s_properties;    /* File system properties. Currently holds
  380.                        on-disk FS format */
  381.  
  382.     /* session statistics */
  383.     int s_disk_reads;
  384.     int s_disk_writes;
  385.     int s_fix_nodes;
  386.     int s_do_balance;
  387.     int s_unneeded_left_neighbor;
  388.     int s_good_search_by_key_reada;
  389.     int s_bmaps;
  390.     int s_bmaps_without_search;
  391.     int s_direct2indirect;
  392.     int s_indirect2direct;
  393.     /* set up when it's ok for reiserfs_read_inode2() to read from
  394.        disk inode with nlink==0. Currently this is only used during
  395.        finish_unfinished() processing at mount time */
  396.     int s_is_unlinked_ok;
  397.     reiserfs_proc_info_data_t s_proc_info_data;
  398.     struct proc_dir_entry *procdir;
  399.     int reserved_blocks;    /* amount of blocks reserved for further allocations */
  400.     spinlock_t bitmap_lock;    /* this lock on now only used to protect reserved_blocks variable */
  401.     struct dentry *priv_root;    /* root of /.reiserfs_priv */
  402. #ifdef CONFIG_REISERFS_FS_XATTR
  403.     struct dentry *xattr_root;    /* root of /.reiserfs_priv/.xa */
  404.     struct rw_semaphore xattr_dir_sem;
  405. #endif
  406.     int j_errno;
  407. #ifdef CONFIG_QUOTA
  408.     char *s_qf_names[MAXQUOTAS];
  409.     int s_jquota_fmt;
  410. #endif
  411. };
  412.  
  413. /* Definitions of reiserfs on-disk properties: */
  414. #define REISERFS_3_5 0
  415. #define REISERFS_3_6 1
  416. #define REISERFS_OLD_FORMAT 2
  417.  
  418. enum reiserfs_mount_options {
  419. /* Mount options */
  420.     REISERFS_LARGETAIL,    /* large tails will be created in a session */
  421.     REISERFS_SMALLTAIL,    /* small (for files less than block size) tails will be created in a session */
  422.     REPLAYONLY,        /* replay journal and return 0. Use by fsck */
  423.     REISERFS_CONVERT,    /* -o conv: causes conversion of old
  424.                    format super block to the new
  425.                    format. If not specified - old
  426.                    partition will be dealt with in a
  427.                    manner of 3.5.x */
  428.  
  429. /* -o hash={tea, rupasov, r5, detect} is meant for properly mounting 
  430. ** reiserfs disks from 3.5.19 or earlier.  99% of the time, this option
  431. ** is not required.  If the normal autodection code can't determine which
  432. ** hash to use (because both hashes had the same value for a file)
  433. ** use this option to force a specific hash.  It won't allow you to override
  434. ** the existing hash on the FS, so if you have a tea hash disk, and mount
  435. ** with -o hash=rupasov, the mount will fail.
  436. */
  437.     FORCE_TEA_HASH,        /* try to force tea hash on mount */
  438.     FORCE_RUPASOV_HASH,    /* try to force rupasov hash on mount */
  439.     FORCE_R5_HASH,        /* try to force rupasov hash on mount */
  440.     FORCE_HASH_DETECT,    /* try to detect hash function on mount */
  441.  
  442.     REISERFS_DATA_LOG,
  443.     REISERFS_DATA_ORDERED,
  444.     REISERFS_DATA_WRITEBACK,
  445.  
  446. /* used for testing experimental features, makes benchmarking new
  447.    features with and without more convenient, should never be used by
  448.    users in any code shipped to users (ideally) */
  449.  
  450.     REISERFS_NO_BORDER,
  451.     REISERFS_NO_UNHASHED_RELOCATION,
  452.     REISERFS_HASHED_RELOCATION,
  453.     REISERFS_ATTRS,
  454.     REISERFS_XATTRS,
  455.     REISERFS_XATTRS_USER,
  456.     REISERFS_POSIXACL,
  457.     REISERFS_BARRIER_NONE,
  458.     REISERFS_BARRIER_FLUSH,
  459.  
  460.     /* Actions on error */
  461.     REISERFS_ERROR_PANIC,
  462.     REISERFS_ERROR_RO,
  463.     REISERFS_ERROR_CONTINUE,
  464.  
  465.     REISERFS_QUOTA,        /* Some quota option specified */
  466.  
  467.     REISERFS_TEST1,
  468.     REISERFS_TEST2,
  469.     REISERFS_TEST3,
  470.     REISERFS_TEST4,
  471.     REISERFS_UNSUPPORTED_OPT,
  472. };
  473.  
  474. #define reiserfs_r5_hash(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_R5_HASH))
  475. #define reiserfs_rupasov_hash(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_RUPASOV_HASH))
  476. #define reiserfs_tea_hash(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_TEA_HASH))
  477. #define reiserfs_hash_detect(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_HASH_DETECT))
  478. #define reiserfs_no_border(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_NO_BORDER))
  479. #define reiserfs_no_unhashed_relocation(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_NO_UNHASHED_RELOCATION))
  480. #define reiserfs_hashed_relocation(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_HASHED_RELOCATION))
  481. #define reiserfs_test4(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_TEST4))
  482.  
  483. #define have_large_tails(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_LARGETAIL))
  484. #define have_small_tails(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_SMALLTAIL))
  485. #define replay_only(s) (REISERFS_SB(s)->s_mount_opt & (1 << REPLAYONLY))
  486. #define reiserfs_attrs(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_ATTRS))
  487. #define old_format_only(s) (REISERFS_SB(s)->s_properties & (1 << REISERFS_3_5))
  488. #define convert_reiserfs(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_CONVERT))
  489. #define reiserfs_data_log(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_DATA_LOG))
  490. #define reiserfs_data_ordered(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_DATA_ORDERED))
  491. #define reiserfs_data_writeback(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_DATA_WRITEBACK))
  492. #define reiserfs_xattrs(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_XATTRS))
  493. #define reiserfs_xattrs_user(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_XATTRS_USER))
  494. #define reiserfs_posixacl(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_POSIXACL))
  495. #define reiserfs_xattrs_optional(s) (reiserfs_xattrs_user(s) || reiserfs_posixacl(s))
  496. #define reiserfs_barrier_none(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_BARRIER_NONE))
  497. #define reiserfs_barrier_flush(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_BARRIER_FLUSH))
  498.  
  499. #define reiserfs_error_panic(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_ERROR_PANIC))
  500. #define reiserfs_error_ro(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_ERROR_RO))
  501.  
  502. void reiserfs_file_buffer(struct buffer_head *bh, int list);
  503. extern struct file_system_type reiserfs_fs_type;
  504. int reiserfs_resize(struct super_block *, unsigned long);
  505.  
  506. #define CARRY_ON                0
  507. #define SCHEDULE_OCCURRED       1
  508.  
  509. #define SB_BUFFER_WITH_SB(s) (REISERFS_SB(s)->s_sbh)
  510. #define SB_JOURNAL(s) (REISERFS_SB(s)->s_journal)
  511. #define SB_JOURNAL_1st_RESERVED_BLOCK(s) (SB_JOURNAL(s)->j_1st_reserved_block)
  512. #define SB_JOURNAL_LEN_FREE(s) (SB_JOURNAL(s)->j_journal_len_free)
  513. #define SB_AP_BITMAP(s) (REISERFS_SB(s)->s_ap_bitmap)
  514.  
  515. #define SB_DISK_JOURNAL_HEAD(s) (SB_JOURNAL(s)->j_header_bh->)
  516.  
  517. /* A safe version of the "bdevname", which returns the "s_id" field of
  518.  * a superblock or else "Null superblock" if the super block is NULL.
  519.  */
  520. static inline char *reiserfs_bdevname(struct super_block *s)
  521. {
  522.     return (s == NULL) ? "Null superblock" : s->s_id;
  523. }
  524.  
  525. #define reiserfs_is_journal_aborted(journal) (unlikely (__reiserfs_is_journal_aborted (journal)))
  526. static inline int __reiserfs_is_journal_aborted(struct reiserfs_journal
  527.                         *journal)
  528. {
  529.     return test_bit(J_ABORTED, &journal->j_state);
  530. }
  531.  
  532. #endif                /* _LINUX_REISER_FS_SB */
  533.